/**
 * API客户端封装类
 * 提供与后端API的统一通信接口
 *
 * @author API Key Framework
 * @version 1.0
 */
class ApiClient {
    constructor(baseUrl = '') {
        this.baseUrl = baseUrl;
        this.defaultHeaders = {
            'Content-Type': 'application/json',
            'Accept': 'application/json'
        };
    }

    /**
     * 发送HTTP请求的通用方法
     *
     * @param {string} url - 请求URL
     * @param {Object} options - 请求选项
     * @returns {Promise<Object>} 响应数据
     */
    async request(url, options = {}) {
        const config = {
            method: 'GET',
            headers: {...this.defaultHeaders, ...options.headers},
            ...options
        };

        if (config.body && typeof config.body === 'object') {
            config.body = JSON.stringify(config.body);
        }

        try {
            const response = await fetch(this.baseUrl + url, config);

            if (!response.ok) {
                const errorData = await response.json().catch(() => ({}));
                throw new Error(errorData.message || `HTTP ${response.status}: ${response.statusText}`);
            }

            const contentType = response.headers.get('content-type');
            if (contentType && contentType.includes('application/json')) {
                return await response.json();
            } else {
                return await response.text();
            }
        } catch (error) {
            console.error('API请求失败:', error);
            throw error;
        }
    }

    /**
     * GET请求
     *
     * @param {string} url - 请求URL
     * @param {Object} params - 查询参数
     * @returns {Promise<Object>} 响应数据
     */
    async get(url, params = {}) {
        const queryString = new URLSearchParams(params).toString();
        const fullUrl = queryString ? `${url}?${queryString}` : url;
        return this.request(fullUrl, {method: 'GET'});
    }

    /**
     * POST请求
     *
     * @param {string} url - 请求URL
     * @param {Object} data - 请求数据
     * @returns {Promise<Object>} 响应数据
     */
    async post(url, data = {}) {
        return this.request(url, {
            method: 'POST',
            body: data
        });
    }

    /**
     * PUT请求
     *
     * @param {string} url - 请求URL
     * @param {Object} data - 请求数据
     * @returns {Promise<Object>} 响应数据
     */
    async put(url, data = {}) {
        return this.request(url, {
            method: 'PUT',
            body: data
        });
    }

    /**
     * PATCH请求
     *
     * @param {string} url - 请求URL
     * @param {Object} data - 请求数据
     * @returns {Promise<Object>} 响应数据
     */
    async patch(url, data = {}) {
        return this.request(url, {
            method: 'PATCH',
            body: data
        });
    }

    /**
     * DELETE请求
     *
     * @param {string} url - 请求URL
     * @returns {Promise<Object>} 响应数据
     */
    async delete(url) {
        return this.request(url, {method: 'DELETE'});
    }

    // ==================== API Key 管理接口 ====================

    /**
     * 获取API Key列表
     *
     * @param {Object} params - 查询参数
     * @returns {Promise<Object>} API Key列表数据
     */
    async getApiKeys(params = {}) {
        return this.get('/api/apikeys', params);
    }

    /**
     * 根据ID获取API Key详情
     *
     * @param {number} id - API Key ID
     * @returns {Promise<Object>} API Key详情数据
     */
    async getApiKey(id) {
        return this.get(`/api/apikeys/${id}`);
    }

    /**
     * 创建新的API Key
     *
     * @param {Object} data - API Key数据
     * @returns {Promise<Object>} 创建结果
     */
    async createApiKey(data) {
        return this.post('/api/apikeys', data);
    }

    /**
     * 更新API Key
     *
     * @param {number} id - API Key ID
     * @param {Object} data - 更新数据
     * @returns {Promise<Object>} 更新结果
     */
    async updateApiKey(id, data) {
        return this.put(`/api/apikeys/${id}`, data);
    }

    /**
     * 删除API Key
     *
     * @param {number} id - API Key ID
     * @returns {Promise<Object>} 删除结果
     */
    async deleteApiKey(id) {
        return this.delete(`/api/apikeys/${id}`);
    }

    /**
     * 启用API Key
     *
     * @param {number} id - API Key ID
     * @returns {Promise<Object>} 操作结果
     */
    async enableApiKey(id) {
        return this.put(`/api/apikeys/${id}/toggle`);
    }

    /**
     * 禁用API Key
     *
     * @param {number} id - API Key ID
     * @returns {Promise<Object>} 操作结果
     */
    async disableApiKey(id) {
        return this.put(`/api/apikeys/${id}/toggle`);
    }

    /**
     * 重新生成API Key
     *
     * @param {number} id - API Key ID
     * @returns {Promise<Object>} 新的API Key
     */
    async regenerateApiKey(id) {
        return this.post(`/api/apikeys/${id}/regenerate`);
    }

    /**
     * 获取API Key统计信息
     * @returns {Promise<Object>} 统计数据
     */
    async getApiKeyStats() {
        return this.get('/api/admin/statistics');
    }

    // ==================== 访问记录相关API ====================

    /**
     * 获取访问记录列表
     *
     * @param {Object} params - 查询参数
     * @returns {Promise<Object>} 访问记录列表
     */
    async getAccessLogs(params = {}) {
        return this.get('/api/access-logs', params);
    }

    /**
     * 根据API Key ID获取访问记录
     *
     * @param {number} apiKeyId - API Key ID
     * @param {Object} params - 查询参数
     * @returns {Promise<Object>} 访问记录列表
     */
    async getAccessLogsByApiKey(apiKeyId, params = {}) {
        return this.get(`/api/access-logs/apikey/${apiKeyId}`, params);
    }

    /**
     * 根据客户端IP获取访问记录
     *
     * @param {string} clientIp - 客户端IP
     * @param {Object} params - 查询参数
     * @returns {Promise<Object>} 访问记录列表
     */
    async getAccessLogsByClientIp(clientIp, params = {}) {
        return this.get(`/api/access-logs/ip/${clientIp}`, params);
    }

    /**
     * 根据响应状态获取访问记录
     *
     * @param {number} responseStatus - 响应状态码
     * @param {Object} params - 查询参数
     * @returns {Promise<Object>} 访问记录列表
     */
    async getAccessLogsByResponseStatus(responseStatus, params = {}) {
        return this.get(`/api/access-logs/status/${responseStatus}`, params);
    }

    /**
     * 根据时间范围获取访问记录
     *
     * @param {string} startTime - 开始时间
     * @param {string} endTime - 结束时间
     * @param {Object} params - 查询参数
     * @returns {Promise<Object>} 访问记录列表
     */
    async getAccessLogsByTimeRange(startTime, endTime, params = {}) {
        return this.get(`/api/access-logs/timerange`, {
            startTime,
            endTime,
            ...params
        });
    }

    /**
     * 搜索访问记录
     *
     * @param {string} keyword - 搜索关键词
     * @param {Object} params - 查询参数
     * @returns {Promise<Object>} 搜索结果
     */
    async searchAccessLogs(keyword, params = {}) {
        return this.get('/api/access-logs/search', {
            keyword,
            ...params
        });
    }

    /**
     * 获取访问记录统计信息
     * @returns {Promise<Object>} 统计数据
     */
    async getAccessLogStats() {
        return this.get('/api/access-logs/stats');
    }

    // ==================== 历史记录相关API ====================

    /**
     * 获取历史记录列表
     *
     * @param {Object} params - 查询参数
     * @returns {Promise<Object>} 历史记录列表
     */
    async getHistory(params = {}) {
        return this.get('/api/history', params);
    }

    /**
     * 根据API Key ID获取历史记录
     *
     * @param {number} apiKeyId - API Key ID
     * @param {Object} params - 查询参数
     * @returns {Promise<Object>} 历史记录列表
     */
    async getHistoryByApiKey(apiKeyId, params = {}) {
        return this.get(`/api/history/apikey/${apiKeyId}`, params);
    }

    /**
     * 根据操作者获取历史记录
     *
     * @param {string} operatorId - 操作者ID
     * @param {Object} params - 查询参数
     * @returns {Promise<Object>} 历史记录列表
     */
    async getHistoryByOperator(operatorId, params = {}) {
        return this.get(`/api/history/operator/${operatorId}`, params);
    }

    /**
     * 根据操作类型获取历史记录
     *
     * @param {string} operation - 操作类型
     * @param {Object} params - 查询参数
     * @returns {Promise<Object>} 历史记录列表
     */
    async getHistoryByOperation(operation, params = {}) {
        return this.get(`/api/history/operation/${operation}`, params);
    }

    /**
     * 根据时间范围获取历史记录
     *
     * @param {string} startTime - 开始时间
     * @param {string} endTime - 结束时间
     * @param {Object} params - 查询参数
     * @returns {Promise<Object>} 历史记录列表
     */
    async getHistoryByTimeRange(startTime, endTime, params = {}) {
        return this.get(`/api/history/timerange`, {
            startTime,
            endTime,
            ...params
        });
    }

    /**
     * 搜索历史记录
     *
     * @param {string} keyword - 搜索关键词
     * @param {Object} params - 查询参数
     * @returns {Promise<Object>} 搜索结果
     */
    async searchHistory(keyword, params = {}) {
        return this.get('/api/history/search', {
            keyword,
            ...params
        });
    }

    /**
     * 获取最近的历史记录
     *
     * @param {number} limit - 限制数量
     * @returns {Promise<Object>} 历史记录列表
     */
    async getRecentHistory(limit = 10) {
        return this.get('/api/history/recent', {limit});
    }

    /**
     * 获取历史记录详情
     *
     * @param {number} id - 历史记录ID
     * @returns {Promise<Object>} 历史记录详情
     */
    async getHistoryDetail(id) {
        return this.get(`/api/history/${id}`);
    }

    /**
     * 比较两个历史记录
     *
     * @param {number} id1 - 第一个历史记录ID
     * @param {number} id2 - 第二个历史记录ID
     * @returns {Promise<Object>} 比较结果
     */
    async compareHistory(id1, id2) {
        return this.get(`/api/history/compare/${id1}/${id2}`);
    }

    /**
     * 获取历史记录统计信息
     * @returns {Promise<Object>} 统计数据
     */
    async getHistoryStats() {
        return this.get('/api/history/stats');
    }

    /**
     * 导出历史记录
     *
     * @param {Object} params - 导出参数
     * @returns {Promise<Object>} 导出结果
     */
    async exportHistory(params = {}) {
        return this.get('/api/history/export', params);
    }

    // ==================== 系统相关API ====================

    /**
     * 获取系统统计信息
     * @returns {Promise<Object>} 系统统计数据
     */
    async getSystemStats() {
        return this.get('/api/system/stats');
    }

    /**
     * 获取用户统计信息
     * @param {string} userId - 用户ID
     * @returns {Promise<Object>} 用户统计数据
     */
    async getUserStats(userId) {
        return this.get(`/api/users/${userId}/stats`);
    }

    /**
     * 获取系统健康状态
     * @returns {Promise<Object>} 系统健康状态
     */
    async getSystemHealth() {
        return this.get('/api/system/health');
    }

    /**
     * 清理过期数据
     * @returns {Promise<Object>} 清理结果
     */
    async cleanupExpiredData() {
        return this.post('/api/system/cleanup');
    }
}

// 导出到全局作用域
if (typeof module !== 'undefined' && module.exports) {
    module.exports = {ApiClient};
} else if (typeof window !== 'undefined') {
    window.ApiClient = ApiClient;
}